// Output created by jacc on Fri Sep 19 00:22:58 CEST 2014

package it.unicam.fishpass.prism;

import java.util.*;
import java.io.*;

class FishPassParser implements FishPassParserTokens {
    private int yyss = 100;
    private int yytok;
    private int yysp = 0;
    private int[] yyst;
    protected int yyerrno = (-1);
    private Object[] yysv;
    private Object yyrv;

    public boolean parse() {
        int yyn = 0;
        yysp = 0;
        yyst = new int[yyss];
        yysv = new Object[yyss];
        yytok = (lexer.token
                 );
    loop:
        for (;;) {
            switch (yyn) {
                case 0:
                    yyst[yysp] = 0;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 145:
                    switch (yytok) {
                        case automaton:
                            yyn = 2;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 1:
                    yyst[yysp] = 1;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 146:
                    switch (yytok) {
                        case ENDINPUT:
                            yyn = 290;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 2:
                    yyst[yysp] = 2;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 147:
                    switch (yytok) {
                        case maxtime:
                            yyn = 4;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 3:
                    yyst[yysp] = 3;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 148:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = 7;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 4:
                    yyst[yysp] = 4;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 149:
                    switch (yytok) {
                        case EQ:
                            yyn = 8;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 5:
                    yyst[yysp] = 5;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 150:
                    switch (yytok) {
                        case ARC:
                            yyn = 10;
                            continue;
                        case URGARC:
                            yyn = 11;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 6:
                    yyst[yysp] = 6;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 151:
                    switch (yytok) {
                        case endautomaton:
                            yyn = 12;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 7:
                    yyst[yysp] = 7;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 152:
                    switch (yytok) {
                        case VAR:
                            yyn = 13;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 8:
                    yyst[yysp] = 8;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 153:
                    switch (yytok) {
                        case NUM:
                            yyn = 14;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 9:
                    yyst[yysp] = 9;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 154:
                    yyn = yys9();
                    continue;

                case 10:
                    yyst[yysp] = 10;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 155:
                    yyn = yys10();
                    continue;

                case 11:
                    yyst[yysp] = 11;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 156:
                    yyn = yys11();
                    continue;

                case 12:
                    yyst[yysp] = 12;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 157:
                    switch (yytok) {
                        case ENDINPUT:
                            yyn = yyr1();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 13:
                    yyst[yysp] = 13;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 158:
                    switch (yytok) {
                        case RSBRACK:
                            yyn = 31;
                            continue;
                        case SEPARATOR:
                            yyn = 32;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 14:
                    yyst[yysp] = 14;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 159:
                    switch (yytok) {
                        case NODE_DEC:
                            yyn = 33;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 15:
                    yyst[yysp] = 15;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 160:
                    yyn = yys15();
                    continue;

                case 16:
                    yyst[yysp] = 16;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 161:
                    switch (yytok) {
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr43();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 17:
                    yyst[yysp] = 17;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 162:
                    switch (yytok) {
                        case RSBRACK:
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr28();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 18:
                    yyst[yysp] = 18;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 163:
                    switch (yytok) {
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr41();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 19:
                    yyst[yysp] = 19;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 164:
                    switch (yytok) {
                        case PLUS:
                        case endautomaton:
                        case LSBRACK:
                            yyn = yyr39();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 20:
                    yyst[yysp] = 20;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 165:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = 7;
                            continue;
                        case PLUS:
                            yyn = 43;
                            continue;
                        case endautomaton:
                            yyn = yyr23();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 21:
                    yyst[yysp] = 21;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 166:
                    switch (yytok) {
                        case CAPS:
                            yyn = 44;
                            continue;
                        case NUMERIC:
                            yyn = 45;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 22:
                    yyst[yysp] = 22;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 167:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr53();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 23:
                    yyst[yysp] = 23;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 168:
                    yyn = yys23();
                    continue;

                case 24:
                    yyst[yysp] = 24;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 169:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr21();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 25:
                    yyst[yysp] = 25;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 170:
                    yyn = yys25();
                    continue;

                case 26:
                    yyst[yysp] = 26;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 171:
                    yyn = yys26();
                    continue;

                case 27:
                    yyst[yysp] = 27;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 172:
                    yyn = yys27();
                    continue;

                case 28:
                    yyst[yysp] = 28;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 173:
                    yyn = yys28();
                    continue;

                case 29:
                    yyst[yysp] = 29;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 174:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr20();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 30:
                    yyst[yysp] = 30;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 175:
                    yyn = yys30();
                    continue;

                case 31:
                    yyst[yysp] = 31;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 176:
                    switch (yytok) {
                        case URGARC:
                        case ARC:
                            yyn = yyr25();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 32:
                    yyst[yysp] = 32;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 177:
                    switch (yytok) {
                        case FALSE:
                            yyn = 23;
                            continue;
                        case TRUE:
                            yyn = 28;
                            continue;
                        case VAR:
                            yyn = 62;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 33:
                    yyst[yysp] = 33;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 178:
                    switch (yytok) {
                        case VAR:
                            yyn = 64;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 34:
                    yyst[yysp] = 34;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 179:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 35:
                    yyst[yysp] = 35;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 180:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 36:
                    yyst[yysp] = 36;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 181:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 37:
                    yyst[yysp] = 37;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 182:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 38:
                    yyst[yysp] = 38;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 183:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 39:
                    yyst[yysp] = 39;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 184:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 40:
                    yyst[yysp] = 40;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 185:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 41:
                    yyst[yysp] = 41;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 186:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 42:
                    yyst[yysp] = 42;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 187:
                    switch (yytok) {
                        case endautomaton:
                            yyn = yyr22();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 43:
                    yyst[yysp] = 43;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 188:
                    yyn = yys43();
                    continue;

                case 44:
                    yyst[yysp] = 44;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 189:
                    yyn = yys44();
                    continue;

                case 45:
                    yyst[yysp] = 45;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 190:
                    switch (yytok) {
                        case VAR:
                            yyn = 76;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 46:
                    yyst[yysp] = 46;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 191:
                    yyn = yys46();
                    continue;

                case 47:
                    yyst[yysp] = 47;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 192:
                    switch (yytok) {
                        case CAPS:
                            yyn = 44;
                            continue;
                        case RBRACK:
                            yyn = 78;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 48:
                    yyst[yysp] = 48;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 193:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr54();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 49:
                    yyst[yysp] = 49;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 194:
                    switch (yytok) {
                        case NUM:
                            yyn = 26;
                            continue;
                        case LBRACK:
                            yyn = 49;
                            continue;
                        case VAR:
                            yyn = 66;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 50:
                    yyst[yysp] = 50;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 195:
                    yyn = yys50();
                    continue;

                case 51:
                    yyst[yysp] = 51;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 196:
                    switch (yytok) {
                        case NUM:
                            yyn = 80;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 52:
                    yyst[yysp] = 52;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 197:
                    yyn = yys52();
                    continue;

                case 53:
                    yyst[yysp] = 53;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 198:
                    yyn = yys53();
                    continue;

                case 54:
                    yyst[yysp] = 54;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 199:
                    switch (yytok) {
                        case NUM:
                            yyn = yyr33();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 55:
                    yyst[yysp] = 55;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 200:
                    switch (yytok) {
                        case NUM:
                            yyn = yyr34();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 56:
                    yyst[yysp] = 56;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 201:
                    switch (yytok) {
                        case NUM:
                            yyn = yyr35();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 57:
                    yyst[yysp] = 57;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 202:
                    switch (yytok) {
                        case NUM:
                            yyn = yyr32();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 58:
                    yyst[yysp] = 58;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 203:
                    switch (yytok) {
                        case NUM:
                            yyn = yyr31();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 59:
                    yyst[yysp] = 59;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 204:
                    switch (yytok) {
                        case VAR:
                            yyn = 81;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 60:
                    yyst[yysp] = 60;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 205:
                    switch (yytok) {
                        case RSBRACK:
                        case CAPS:
                            yyn = yyr27();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 61:
                    yyst[yysp] = 61;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 206:
                    switch (yytok) {
                        case CAPS:
                            yyn = 82;
                            continue;
                        case RSBRACK:
                            yyn = 83;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 62:
                    yyst[yysp] = 62;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 207:
                    yyn = yys62();
                    continue;

                case 63:
                    yyst[yysp] = 63;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 208:
                    switch (yytok) {
                        case COMMA:
                            yyn = 84;
                            continue;
                        case SEMI:
                            yyn = 85;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 64:
                    yyst[yysp] = 64;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 209:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr6();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 65:
                    yyst[yysp] = 65;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 210:
                    yyn = yys65();
                    continue;

                case 66:
                    yyst[yysp] = 66;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 211:
                    switch (yytok) {
                        case AUTODECREMENT:
                            yyn = 52;
                            continue;
                        case AUTOINCREMENT:
                            yyn = 53;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 67:
                    yyst[yysp] = 67;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 212:
                    yyn = yys67();
                    continue;

                case 68:
                    yyst[yysp] = 68;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 213:
                    yyn = yys68();
                    continue;

                case 69:
                    yyst[yysp] = 69;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 214:
                    yyn = yys69();
                    continue;

                case 70:
                    yyst[yysp] = 70;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 215:
                    yyn = yys70();
                    continue;

                case 71:
                    yyst[yysp] = 71;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 216:
                    yyn = yys71();
                    continue;

                case 72:
                    yyst[yysp] = 72;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 217:
                    yyn = yys72();
                    continue;

                case 73:
                    yyst[yysp] = 73;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 218:
                    yyn = yys73();
                    continue;

                case 74:
                    yyst[yysp] = 74;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 219:
                    switch (yytok) {
                        case PLUS:
                        case endautomaton:
                        case LSBRACK:
                            yyn = yyr38();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 75:
                    yyst[yysp] = 75;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 220:
                    switch (yytok) {
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr42();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 76:
                    yyst[yysp] = 76;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 221:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = 86;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 77:
                    yyst[yysp] = 77;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 222:
                    yyn = yys77();
                    continue;

                case 78:
                    yyst[yysp] = 78;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 223:
                    switch (yytok) {
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr44();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 79:
                    yyst[yysp] = 79;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 224:
                    yyn = yys79();
                    continue;

                case 80:
                    yyst[yysp] = 80;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 225:
                    switch (yytok) {
                        case RSBRACK:
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr29();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 81:
                    yyst[yysp] = 81;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 226:
                    switch (yytok) {
                        case EQ:
                            yyn = 54;
                            continue;
                        case GEQ:
                            yyn = 55;
                            continue;
                        case GR:
                            yyn = 56;
                            continue;
                        case LEQ:
                            yyn = 57;
                            continue;
                        case LS:
                            yyn = 58;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 82:
                    yyst[yysp] = 82;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 227:
                    switch (yytok) {
                        case FALSE:
                            yyn = 23;
                            continue;
                        case TRUE:
                            yyn = 28;
                            continue;
                        case VAR:
                            yyn = 62;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 83:
                    yyst[yysp] = 83;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 228:
                    switch (yytok) {
                        case URGARC:
                        case ARC:
                            yyn = yyr24();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 84:
                    yyst[yysp] = 84;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 229:
                    switch (yytok) {
                        case VAR:
                            yyn = 89;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 85:
                    yyst[yysp] = 85;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 230:
                    switch (yytok) {
                        case CLOCK_DEC:
                            yyn = 90;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 86:
                    yyst[yysp] = 86;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 231:
                    switch (yytok) {
                        case VAR:
                            yyn = 93;
                            continue;
                        case RSBRACK:
                        case COMMA:
                            yyn = yyr47();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 87:
                    yyst[yysp] = 87;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 232:
                    switch (yytok) {
                        case NUM:
                            yyn = 94;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 88:
                    yyst[yysp] = 88;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 233:
                    switch (yytok) {
                        case RSBRACK:
                        case CAPS:
                            yyn = yyr26();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 89:
                    yyst[yysp] = 89;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 234:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr5();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 90:
                    yyst[yysp] = 90;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 235:
                    switch (yytok) {
                        case VAR:
                            yyn = 97;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 91:
                    yyst[yysp] = 91;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 236:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                            yyn = yyr46();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 92:
                    yyst[yysp] = 92;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 237:
                    switch (yytok) {
                        case COMMA:
                            yyn = 98;
                            continue;
                        case RSBRACK:
                            yyn = 99;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 93:
                    yyst[yysp] = 93;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 238:
                    switch (yytok) {
                        case EQ:
                            yyn = 100;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 94:
                    yyst[yysp] = 94;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 239:
                    switch (yytok) {
                        case RSBRACK:
                        case RBRACK:
                        case NUMERIC:
                        case CAPS:
                            yyn = yyr30();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 95:
                    yyst[yysp] = 95;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 240:
                    switch (yytok) {
                        case COMMA:
                            yyn = 101;
                            continue;
                        case SEMI:
                            yyn = 102;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 96:
                    yyst[yysp] = 96;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 241:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr8();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 97:
                    yyst[yysp] = 97;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 242:
                    switch (yytok) {
                        case EQ:
                            yyn = 103;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 98:
                    yyst[yysp] = 98;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 243:
                    switch (yytok) {
                        case VAR:
                            yyn = 93;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 99:
                    yyst[yysp] = 99;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 244:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = 105;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 100:
                    yyst[yysp] = 100;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 245:
                    yyn = yys100();
                    continue;

                case 101:
                    yyst[yysp] = 101;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 246:
                    switch (yytok) {
                        case VAR:
                            yyn = 97;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 102:
                    yyst[yysp] = 102;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 247:
                    switch (yytok) {
                        case VARIABLE_DEC:
                            yyn = 112;
                            continue;
                        case LSBRACK:
                            yyn = yyr4();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 103:
                    yyst[yysp] = 103;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 248:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = 113;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 104:
                    yyst[yysp] = 104;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 249:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                            yyn = yyr45();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 105:
                    yyst[yysp] = 105;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 250:
                    switch (yytok) {
                        case VAR:
                            yyn = 115;
                            continue;
                        case RSBRACK:
                        case COMMA:
                            yyn = yyr70();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 106:
                    yyst[yysp] = 106;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 251:
                    yyn = yys106();
                    continue;

                case 107:
                    yyst[yysp] = 107;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 252:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                        case RBRACK:
                        case CAPS:
                            yyn = yyr51();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 108:
                    yyst[yysp] = 108;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 253:
                    switch (yytok) {
                        case CAPS:
                            yyn = 116;
                            continue;
                        case RSBRACK:
                        case COMMA:
                            yyn = yyr48();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 109:
                    yyst[yysp] = 109;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 254:
                    yyn = yys109();
                    continue;

                case 110:
                    yyst[yysp] = 110;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 255:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr7();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 111:
                    yyst[yysp] = 111;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 256:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = yyr2();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 112:
                    yyst[yysp] = 112;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 257:
                    switch (yytok) {
                        case VAR:
                            yyn = 121;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 113:
                    yyst[yysp] = 113;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 258:
                    switch (yytok) {
                        case MINUSINF:
                            yyn = 123;
                            continue;
                        case NUMERIC:
                            yyn = 124;
                            continue;
                        case PLUSINF:
                            yyn = 125;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 114:
                    yyst[yysp] = 114;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 259:
                    switch (yytok) {
                        case COMMA:
                            yyn = 126;
                            continue;
                        case RSBRACK:
                            yyn = 127;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 115:
                    yyst[yysp] = 115;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 260:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                            yyn = yyr69();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 116:
                    yyst[yysp] = 116;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 261:
                    yyn = yys116();
                    continue;

                case 117:
                    yyst[yysp] = 117;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 262:
                    switch (yytok) {
                        case CAPS:
                            yyn = 116;
                            continue;
                        case RBRACK:
                            yyn = 129;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 118:
                    yyst[yysp] = 118;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 263:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr14();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 119:
                    yyst[yysp] = 119;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 264:
                    switch (yytok) {
                        case COMMA:
                            yyn = 130;
                            continue;
                        case SEMI:
                            yyn = 131;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 120:
                    yyst[yysp] = 120;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 265:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr17();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 121:
                    yyst[yysp] = 121;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 266:
                    switch (yytok) {
                        case EQ:
                            yyn = 132;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 122:
                    yyst[yysp] = 122;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 267:
                    switch (yytok) {
                        case POINT:
                            yyn = 133;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 123:
                    yyst[yysp] = 123;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 268:
                    switch (yytok) {
                        case RSBRACK:
                        case POINT:
                            yyn = yyr12();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 124:
                    yyst[yysp] = 124;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 269:
                    switch (yytok) {
                        case RSBRACK:
                        case POINT:
                            yyn = yyr10();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 125:
                    yyst[yysp] = 125;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 270:
                    switch (yytok) {
                        case RSBRACK:
                        case POINT:
                            yyn = yyr11();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 126:
                    yyst[yysp] = 126;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 271:
                    switch (yytok) {
                        case VAR:
                            yyn = 134;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 127:
                    yyst[yysp] = 127;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 272:
                    switch (yytok) {
                        case PLUS:
                        case endautomaton:
                        case LSBRACK:
                            yyn = yyr40();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 128:
                    yyst[yysp] = 128;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 273:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                        case RBRACK:
                        case CAPS:
                            yyn = yyr50();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 129:
                    yyst[yysp] = 129;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 274:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                        case RBRACK:
                        case CAPS:
                            yyn = yyr52();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 130:
                    yyst[yysp] = 130;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 275:
                    switch (yytok) {
                        case VAR:
                            yyn = 121;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 131:
                    yyst[yysp] = 131;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 276:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = yyr3();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 132:
                    yyst[yysp] = 132;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 277:
                    switch (yytok) {
                        case LSBRACK:
                            yyn = 113;
                            continue;
                        case NUMERIC:
                            yyn = 136;
                            continue;
                        case bool:
                            yyn = 137;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 133:
                    yyst[yysp] = 133;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 278:
                    switch (yytok) {
                        case POINT:
                            yyn = 138;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 134:
                    yyst[yysp] = 134;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 279:
                    switch (yytok) {
                        case RSBRACK:
                        case COMMA:
                            yyn = yyr68();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 135:
                    yyst[yysp] = 135;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 280:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr13();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 136:
                    yyst[yysp] = 136;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 281:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr15();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 137:
                    yyst[yysp] = 137;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 282:
                    switch (yytok) {
                        case l_init:
                            yyn = 139;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 138:
                    yyst[yysp] = 138;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 283:
                    switch (yytok) {
                        case MINUSINF:
                            yyn = 123;
                            continue;
                        case NUMERIC:
                            yyn = 124;
                            continue;
                        case PLUSINF:
                            yyn = 125;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 139:
                    yyst[yysp] = 139;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 284:
                    switch (yytok) {
                        case FALSE:
                            yyn = 23;
                            continue;
                        case TRUE:
                            yyn = 28;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 140:
                    yyst[yysp] = 140;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 285:
                    switch (yytok) {
                        case RSBRACK:
                            yyn = 142;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 141:
                    yyst[yysp] = 141;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 286:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr16();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 142:
                    yyst[yysp] = 142;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 287:
                    switch (yytok) {
                        case l_init:
                            yyn = 143;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 143:
                    yyst[yysp] = 143;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 288:
                    switch (yytok) {
                        case NUMERIC:
                            yyn = 144;
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 144:
                    yyst[yysp] = 144;
                    yysv[yysp] = (lexer.semanticValue
                                 );
                    yytok = (nextToken()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 289:
                    switch (yytok) {
                        case SEMI:
                        case COMMA:
                            yyn = yyr9();
                            continue;
                    }
                    yyn = 293;
                    continue;

                case 290:
                    return true;
                case 291:
                    yyerror("stack overflow");
                case 292:
                    return false;
                case 293:
                    yyerror("syntax error");
                    return false;
            }
        }
    }

    protected void yyexpand() {
        int[] newyyst = new int[2*yyst.length];
        Object[] newyysv = new Object[2*yyst.length];
        for (int i=0; i<yyst.length; i++) {
            newyyst[i] = yyst[i];
            newyysv[i] = yysv[i];
        }
        yyst = newyyst;
        yysv = newyysv;
    }

    private int yys9() {
        switch (yytok) {
            case FALSE:
                return 23;
            case FF:
                return 24;
            case LBRACK:
                return 25;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TRUE:
                return 28;
            case TT:
                return 29;
            case VAR:
                return 30;
        }
        return 293;
    }

    private int yys10() {
        switch (yytok) {
            case TILDE:
            case LBRACK:
            case NUM:
            case FF:
            case FALSE:
            case VAR:
            case TT:
            case TRUE:
                return yyr36();
        }
        return 293;
    }

    private int yys11() {
        switch (yytok) {
            case TILDE:
            case LBRACK:
            case NUM:
            case FF:
            case FALSE:
            case VAR:
            case TT:
            case TRUE:
                return yyr37();
        }
        return 293;
    }

    private int yys15() {
        switch (yytok) {
            case DIVIDE:
                return 34;
            case EQ:
                return 35;
            case LEQ:
                return 36;
            case LS:
                return 37;
            case MINUS:
                return 38;
            case MOD:
                return 39;
            case PLUS:
                return 40;
            case TIMES:
                return 41;
        }
        return 293;
    }

    private int yys23() {
        switch (yytok) {
            case SEMI:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case NUMERIC:
            case CAPS:
                return yyr19();
        }
        return 293;
    }

    private int yys25() {
        switch (yytok) {
            case FALSE:
                return 23;
            case FF:
                return 24;
            case LBRACK:
                return 25;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TRUE:
                return 28;
            case TT:
                return 29;
            case VAR:
                return 30;
        }
        return 293;
    }

    private int yys26() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr59();
        }
        return 293;
    }

    private int yys27() {
        switch (yytok) {
            case FF:
                return 24;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TT:
                return 29;
            case LBRACK:
                return 49;
            case VAR:
                return 50;
        }
        return 293;
    }

    private int yys28() {
        switch (yytok) {
            case SEMI:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case NUMERIC:
            case CAPS:
                return yyr18();
        }
        return 293;
    }

    private int yys30() {
        switch (yytok) {
            case AUTODECREMENT:
                return 52;
            case AUTOINCREMENT:
                return 53;
            case EQ:
                return 54;
            case GEQ:
                return 55;
            case GR:
                return 56;
            case LEQ:
                return 57;
            case LS:
                return 58;
            case MINUS:
                return 59;
            case RBRACK:
            case NUMERIC:
            case CAPS:
                return yyr55();
        }
        return 293;
    }

    private int yys43() {
        switch (yytok) {
            case FALSE:
                return 23;
            case FF:
                return 24;
            case LBRACK:
                return 25;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TRUE:
                return 28;
            case TT:
                return 29;
            case VAR:
                return 30;
        }
        return 293;
    }

    private int yys44() {
        switch (yytok) {
            case FALSE:
                return 23;
            case FF:
                return 24;
            case LBRACK:
                return 25;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TRUE:
                return 28;
            case TT:
                return 29;
            case VAR:
                return 30;
        }
        return 293;
    }

    private int yys46() {
        switch (yytok) {
            case DIVIDE:
                return 34;
            case EQ:
                return 35;
            case LEQ:
                return 36;
            case LS:
                return 37;
            case MINUS:
                return 38;
            case MOD:
                return 39;
            case PLUS:
                return 40;
            case TIMES:
                return 41;
            case RBRACK:
                return 77;
        }
        return 293;
    }

    private int yys50() {
        switch (yytok) {
            case AUTODECREMENT:
                return 52;
            case AUTOINCREMENT:
                return 53;
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case NUMERIC:
            case CAPS:
                return yyr55();
        }
        return 293;
    }

    private int yys52() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr67();
        }
        return 293;
    }

    private int yys53() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr66();
        }
        return 293;
    }

    private int yys62() {
        switch (yytok) {
            case EQ:
                return 54;
            case GEQ:
                return 55;
            case GR:
                return 56;
            case LEQ:
                return 57;
            case LS:
                return 58;
            case MINUS:
                return 59;
        }
        return 293;
    }

    private int yys65() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr63();
        }
        return 293;
    }

    private int yys67() {
        switch (yytok) {
            case DIVIDE:
                return 34;
            case MINUS:
                return 38;
            case MOD:
                return 39;
            case PLUS:
                return 40;
            case TIMES:
                return 41;
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case NUMERIC:
            case CAPS:
                return yyr56();
        }
        return 293;
    }

    private int yys68() {
        switch (yytok) {
            case DIVIDE:
                return 34;
            case MINUS:
                return 38;
            case MOD:
                return 39;
            case PLUS:
                return 40;
            case TIMES:
                return 41;
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case NUMERIC:
            case CAPS:
                return yyr57();
        }
        return 293;
    }

    private int yys69() {
        switch (yytok) {
            case DIVIDE:
                return 34;
            case MINUS:
                return 38;
            case MOD:
                return 39;
            case PLUS:
                return 40;
            case TIMES:
                return 41;
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case NUMERIC:
            case CAPS:
                return yyr58();
        }
        return 293;
    }

    private int yys70() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr62();
        }
        return 293;
    }

    private int yys71() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr64();
        }
        return 293;
    }

    private int yys72() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr60();
        }
        return 293;
    }

    private int yys73() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr61();
        }
        return 293;
    }

    private int yys77() {
        switch (yytok) {
            case LEQ:
            case RSBRACK:
            case COMMA:
            case RBRACK:
            case PLUS:
            case NUMERIC:
            case MOD:
            case CAPS:
            case MINUS:
            case EQ:
            case TIMES:
            case LS:
            case DIVIDE:
                return yyr65();
        }
        return 293;
    }

    private int yys79() {
        switch (yytok) {
            case DIVIDE:
                return 34;
            case MINUS:
                return 38;
            case MOD:
                return 39;
            case PLUS:
                return 40;
            case TIMES:
                return 41;
            case RBRACK:
                return 77;
        }
        return 293;
    }

    private int yys100() {
        switch (yytok) {
            case FF:
                return 24;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TT:
                return 29;
            case VAR:
                return 50;
            case LBRACK:
                return 109;
        }
        return 293;
    }

    private int yys106() {
        switch (yytok) {
            case DIVIDE:
                return 34;
            case EQ:
                return 35;
            case LEQ:
                return 36;
            case LS:
                return 37;
            case MINUS:
                return 38;
            case MOD:
                return 39;
            case PLUS:
                return 40;
            case TIMES:
                return 41;
            case RSBRACK:
            case COMMA:
                return yyr49();
        }
        return 293;
    }

    private int yys109() {
        switch (yytok) {
            case FF:
                return 24;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TT:
                return 29;
            case VAR:
                return 50;
            case LBRACK:
                return 109;
        }
        return 293;
    }

    private int yys116() {
        switch (yytok) {
            case FF:
                return 24;
            case NUM:
                return 26;
            case TILDE:
                return 27;
            case TT:
                return 29;
            case VAR:
                return 50;
            case LBRACK:
                return 109;
        }
        return 293;
    }

    private int yyr1() { // AUTOMATON_DEF : automaton DECLARATIONS STATES endautomaton
        {/* EMPTY PRODUCTION */}
        yysv[yysp-=4] = yyrv;
        return 1;
    }

    private int yyr36() { // ARCS : ARC
        {System.out.println("Arch");
        yyrv = new Boolean(false);}
        yysv[yysp-=1] = yyrv;
        return 9;
    }

    private int yyr37() { // ARCS : URGARC
        {System.out.println("Urgent arch");
        yyrv = new Boolean(true);}
        yysv[yysp-=1] = yyrv;
        return 9;
    }

    private int yyr48() { // ASSIGN : VAR EQ BEXPRS
        {yyrv = new Assign(((String)yysv[yysp-3]), ((BooleanExpression)yysv[yysp-1]));}
        yysv[yysp-=3] = yyrv;
        return yypASSIGN();
    }

    private int yyr49() { // ASSIGN : VAR EQ AEXPR
        {yyrv = new Assign(((String)yysv[yysp-3]), ((ArithmeticExpression)yysv[yysp-1]));}
        yysv[yysp-=3] = yyrv;
        return yypASSIGN();
    }

    private int yypASSIGN() {
        switch (yyst[yysp-1]) {
            case 86: return 91;
            default: return 104;
        }
    }

    private int yyr45() { // ASSIGNMENT : ASSIGNMENT COMMA ASSIGN
        {ArrayList<Assign> temp = new ArrayList<Assign>();
        temp.addAll(((ArrayList)yysv[yysp-3]));
        temp.add(((Assign)yysv[yysp-1]));
        yyrv = temp;}
        yysv[yysp-=3] = yyrv;
        return 92;
    }

    private int yyr46() { // ASSIGNMENT : ASSIGN
        {ArrayList<Assign> temp = new ArrayList<Assign>();
        temp.add(((Assign)yysv[yysp-1]));
        yyrv = temp;}
        yysv[yysp-=1] = yyrv;
        return 92;
    }

    private int yyr47() { // ASSIGNMENT : /* empty */
        {yyrv = new ArrayList<Assign>();}
        yysv[yysp-=0] = yyrv;
        return 92;
    }

    private int yyr59() { // AEXPR : NUM
        {yyrv = new ArithmeticExpression(((Integer)yysv[yysp-1]));}
        yysv[yysp-=1] = yyrv;
        return yypAEXPR();
    }

    private int yyr60() { // AEXPR : AEXPR PLUS AEXPR
        {yyrv = new ArithmeticExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),'+');}
        yysv[yysp-=3] = yyrv;
        return yypAEXPR();
    }

    private int yyr61() { // AEXPR : AEXPR TIMES AEXPR
        {yyrv = new ArithmeticExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),'*');}
        yysv[yysp-=3] = yyrv;
        return yypAEXPR();
    }

    private int yyr62() { // AEXPR : AEXPR MINUS AEXPR
        {yyrv = new ArithmeticExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),'-');}
        yysv[yysp-=3] = yyrv;
        return yypAEXPR();
    }

    private int yyr63() { // AEXPR : AEXPR DIVIDE AEXPR
        {yyrv = new ArithmeticExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),'/');}
        yysv[yysp-=3] = yyrv;
        return yypAEXPR();
    }

    private int yyr64() { // AEXPR : AEXPR MOD AEXPR
        {yyrv = new ArithmeticExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),'%');}
        yysv[yysp-=3] = yyrv;
        return yypAEXPR();
    }

    private int yyr65() { // AEXPR : LBRACK AEXPR RBRACK
        {yyrv = ((ArithmeticExpression)yysv[yysp-2]);}
        yysv[yysp-=3] = yyrv;
        return yypAEXPR();
    }

    private int yyr66() { // AEXPR : VAR AUTOINCREMENT
        {
     float value = 0;
     for(Declaration d : listOfVariables){
      if(d.getVar().equalsIgnoreCase(((String)yysv[yysp-2])))
      {
       value = d.getValue();
       break;
      }
      }
     yyrv = new ArithmeticExpression(((String)yysv[yysp-2]), 'p', value);
     }
        yysv[yysp-=2] = yyrv;
        return yypAEXPR();
    }

    private int yyr67() { // AEXPR : VAR AUTODECREMENT
        {
     float value = 0;
     for(Declaration d : listOfVariables){
      if(d.getVar().equalsIgnoreCase(((String)yysv[yysp-2])))
      {
       value = d.getValue();
       break;
      }
     }yyrv = new ArithmeticExpression(((String)yysv[yysp-2]), 'm', value);
     }
        yysv[yysp-=2] = yyrv;
        return yypAEXPR();
    }

    private int yypAEXPR() {
        switch (yyst[yysp-1]) {
            case 109: return 46;
            case 100: return 106;
            case 49: return 79;
            case 41: return 73;
            case 40: return 72;
            case 39: return 71;
            case 38: return 70;
            case 37: return 69;
            case 36: return 68;
            case 35: return 67;
            case 34: return 65;
            case 25: return 46;
            default: return 15;
        }
    }

    private int yyr53() { // BEXPR : SHORTBOOL
        {yyrv = new BooleanExpression(((Boolean)yysv[yysp-1]));}
        yysv[yysp-=1] = yyrv;
        return yypBEXPR();
    }

    private int yyr54() { // BEXPR : TILDE BEXPR
        {yyrv = new BooleanExpression(((BooleanExpression)yysv[yysp-1]), Constant.NOT);}
        yysv[yysp-=2] = yyrv;
        return yypBEXPR();
    }

    private int yyr55() { // BEXPR : VAR
        {yyrv = new BooleanExpression(((String)yysv[yysp-1]));}
        yysv[yysp-=1] = yyrv;
        return yypBEXPR();
    }

    private int yyr56() { // BEXPR : AEXPR EQ AEXPR
        {yyrv = new BooleanExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),Constant.EQ);}
        yysv[yysp-=3] = yyrv;
        return yypBEXPR();
    }

    private int yyr57() { // BEXPR : AEXPR LEQ AEXPR
        {yyrv = new BooleanExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),Constant.LEQ);}
        yysv[yysp-=3] = yyrv;
        return yypBEXPR();
    }

    private int yyr58() { // BEXPR : AEXPR LS AEXPR
        {yyrv = new BooleanExpression(((ArithmeticExpression)yysv[yysp-3]),((ArithmeticExpression)yysv[yysp-1]),Constant.LS);}
        yysv[yysp-=3] = yyrv;
        return yypBEXPR();
    }

    private int yypBEXPR() {
        switch (yyst[yysp-1]) {
            case 116: return 107;
            case 109: return 107;
            case 100: return 107;
            case 27: return 48;
            default: return 16;
        }
    }

    private int yyr50() { // BEXPRS : BEXPRS CAPS BEXPRS
        {yyrv = new BooleanExpression(((BooleanExpression)yysv[yysp-3]),((BooleanExpression)yysv[yysp-1]));}
        yysv[yysp-=3] = yyrv;
        return yypBEXPRS();
    }

    private int yyr51() { // BEXPRS : BEXPR
        yysp -= 1;
        return yypBEXPRS();
    }

    private int yyr52() { // BEXPRS : LBRACK BEXPRS RBRACK
        {yyrv = ((BooleanExpression)yysv[yysp-2]);}
        yysv[yysp-=3] = yyrv;
        return yypBEXPRS();
    }

    private int yypBEXPRS() {
        switch (yyst[yysp-1]) {
            case 109: return 117;
            case 100: return 108;
            default: return 128;
        }
    }

    private int yyr18() { // BOOLEAN : TRUE
        {yyrv = new Boolean(true);}
        yysv[yysp-=1] = yyrv;
        return yypBOOLEAN();
    }

    private int yyr19() { // BOOLEAN : FALSE
        {yyrv = new Boolean(false);}
        yysv[yysp-=1] = yyrv;
        return yypBOOLEAN();
    }

    private int yypBOOLEAN() {
        switch (yyst[yysp-1]) {
            case 139: return 141;
            default: return 17;
        }
    }

    private int yyr7() { // CLOCK_DECLARATION : CLOCK_DECLARATION COMMA NUMERIC_REST
        yysp -= 3;
        return 95;
    }

    private int yyr8() { // CLOCK_DECLARATION : NUMERIC_REST
        yysp -= 1;
        return 95;
    }

    private int yyr28() { // CONSTRAINT : BOOLEAN
        {yyrv = new ConstraintExpression(((Boolean)yysv[yysp-1]));}
        yysv[yysp-=1] = yyrv;
        return yypCONSTRAINT();
    }

    private int yyr29() { // CONSTRAINT : VAR SIM NUM
        {yyrv = new ConstraintExpression(((String)yysv[yysp-3]),((Integer)yysv[yysp-2]),((Integer)yysv[yysp-1]));}
        yysv[yysp-=3] = yyrv;
        return yypCONSTRAINT();
    }

    private int yyr30() { // CONSTRAINT : VAR MINUS VAR SIM NUM
        {yyrv = new ConstraintExpression(((String)yysv[yysp-5]),((String)yysv[yysp-3]),((Integer)yysv[yysp-2]),((Integer)yysv[yysp-1]));}
        yysv[yysp-=5] = yyrv;
        return yypCONSTRAINT();
    }

    private int yypCONSTRAINT() {
        switch (yyst[yysp-1]) {
            case 82: return 60;
            case 32: return 60;
            default: return 18;
        }
    }

    private int yyr26() { // CONSTRAINTS : CONSTRAINTS CAPS CONSTRAINTS
        {yyrv = new ConstraintExpression(((ConstraintExpression)yysv[yysp-3]),((ConstraintExpression)yysv[yysp-1]));
                }
        yysv[yysp-=3] = yyrv;
        return yypCONSTRAINTS();
    }

    private int yyr27() { // CONSTRAINTS : CONSTRAINT
        yysp -= 1;
        return yypCONSTRAINTS();
    }

    private int yypCONSTRAINTS() {
        switch (yyst[yysp-1]) {
            case 32: return 61;
            default: return 88;
        }
    }

    private int yyr15() { // DECLARATION : VAR EQ NUMERIC
        {System.out.println("Declaration:" + ((String)yysv[yysp-3]) + "=" + ((Float)yysv[yysp-1]) );
                Declaration variable = new Declaration (((String)yysv[yysp-3]), ((Float)yysv[yysp-1]));
                if (listOfNames.contains(((String)yysv[yysp-3]))){
                    errorString = "The name (variable) "+ ((String)yysv[yysp-3]) +" is already used";
                    return error;
                    }
                listOfVariables.add(variable);
                listOfNames.add(((String)yysv[yysp-3]));
        }
        yysv[yysp-=3] = yyrv;
        return yypDECLARATION();
    }

    private int yyr16() { // DECLARATION : VAR EQ bool l_init BOOLEAN
        {System.out.println("Declaration:" + ((String)yysv[yysp-5]) +" set at "+ ((Boolean)yysv[yysp-1]));
                if (listOfNames.contains(((String)yysv[yysp-5]))){
                    errorString = "The name (variable) "+ ((String)yysv[yysp-5]) + " is already used";
                    return error;
                }
                Declaration variable;
                if (((Boolean)yysv[yysp-1])==true){
                    variable = new Declaration (((String)yysv[yysp-5]), ((Boolean)yysv[yysp-1]));
                }
                else{
                    variable = new Declaration (((String)yysv[yysp-5]), ((Boolean)yysv[yysp-1]));
                }
                listOfVariables.add(variable);
                listOfNames.add(((String)yysv[yysp-5]));
        }
        yysv[yysp-=5] = yyrv;
        return yypDECLARATION();
    }

    private int yyr17() { // DECLARATION : NUMERIC_REST
        {
                
                }
        yysv[yysp-=1] = yyrv;
        return yypDECLARATION();
    }

    private int yypDECLARATION() {
        switch (yyst[yysp-1]) {
            case 112: return 118;
            default: return 135;
        }
    }

    private int yyr2() { // DECLARATIONS : maxtime EQ NUM NODE_DEC NODE_DECLARATION SEMI CLOCK_DEC CLOCK_DECLARATION SEMI VARIABLESORNOT
        {  
                        max = ((Integer)yysv[yysp-8]);
                        // Create the array of declarations for the semantics application
                        listOfClocks.add(new Declaration("MAXTIME", max));      //...but first add the MAXTIME clock to the clocks structure
                        decs = new Declaration[listOfClocks.size() + listOfVariables.size()];
                        for (int i = 0; i < listOfClocks.size(); i++)
                                decs[i] = listOfClocks.get(i);
                        for (int i = 0; i < listOfVariables.size(); i++)
                                decs[i + listOfClocks.size()] = listOfVariables.get(i);
                        System.out.println("List of clocks/variables correctly created...");
                }
        yysv[yysp-=10] = yyrv;
        return 3;
    }

    private int yyr13() { // DEFINITIONS : DEFINITIONS COMMA DECLARATION
        yysp -= 3;
        return 119;
    }

    private int yyr14() { // DEFINITIONS : DECLARATION
        yysp -= 1;
        return 119;
    }

    private int yyr40() { // EDGE : GUARD NUMERIC VAR LSBRACK ASSIGNMENT RSBRACK LSBRACK RESET RSBRACK
        {//System.out.println("Probability " + ((Float)yysv[yysp-8]) + ", arrival node: " + ((String)yysv[yysp-7]));
        yyrv = new Edge(((Guard)yysv[yysp-9]), ((Float)yysv[yysp-8]), ((String)yysv[yysp-7]), ((ArrayList)yysv[yysp-5]), ((ArrayList)yysv[yysp-2]), false);}
        yysv[yysp-=9] = yyrv;
        switch (yyst[yysp-1]) {
            case 9: return 19;
            default: return 74;
        }
    }

    private int yyr38() { // EDGE_SET : EDGE_SET PLUS EDGE
        {
                        ((ArrayList)yysv[yysp-3]).add(((Edge)yysv[yysp-1]));
                        for(int i = 0; i < ((ArrayList)yysv[yysp-3]).size() - 1; i++)
                        {
                                System.out.print(((Edge)((ArrayList)yysv[yysp-3]).get(i)).getProbability() + " -- ");
                        }                                               
                        System.out.println(((Edge) ((ArrayList)yysv[yysp-3]).get(((ArrayList)yysv[yysp-3]).size() - 1)).getProbability());
                        yyrv = ((ArrayList)yysv[yysp-3]);
                }
        yysv[yysp-=3] = yyrv;
        return 20;
    }

    private int yyr39() { // EDGE_SET : EDGE
        {
                System.out.println("EDGE");
                System.out.println(((Edge)yysv[yysp-1]).getProbability());
                ArrayList<Edge> list = new ArrayList<Edge>();
                list.add(((Edge)yysv[yysp-1]));
                yyrv = list;
                }
        yysv[yysp-=1] = yyrv;
        return 20;
    }

    private int yyr41() { // GUARD : CONSTRAINT
        {yyrv = new Guard (((ConstraintExpression)yysv[yysp-1]));}
        yysv[yysp-=1] = yyrv;
        return yypGUARD();
    }

    private int yyr42() { // GUARD : GUARD CAPS GUARD
        {yyrv = new Guard (((Guard)yysv[yysp-3]), ((Guard)yysv[yysp-1]));}
        yysv[yysp-=3] = yyrv;
        return yypGUARD();
    }

    private int yyr43() { // GUARD : BEXPR
        {yyrv = new Guard (((BooleanExpression)yysv[yysp-1]));}
        yysv[yysp-=1] = yyrv;
        return yypGUARD();
    }

    private int yyr44() { // GUARD : LBRACK GUARD RBRACK
        {yyrv = ((Guard)yysv[yysp-2]);}
        yysv[yysp-=3] = yyrv;
        return yypGUARD();
    }

    private int yypGUARD() {
        switch (yyst[yysp-1]) {
            case 44: return 75;
            case 25: return 47;
            default: return 21;
        }
    }

    private int yyr24() { // NODE : LSBRACK VAR SEPARATOR CONSTRAINTS RSBRACK
        {locations.put(((String)yysv[yysp-4]), ((ConstraintExpression)yysv[yysp-2]));
        yyrv = ((String)yysv[yysp-4]);
        }
        yysv[yysp-=5] = yyrv;
        return 5;
    }

    private int yyr25() { // NODE : LSBRACK VAR RSBRACK
        {locations.put(((String)yysv[yysp-2]), null);
        yyrv = ((String)yysv[yysp-2]);
        }
        yysv[yysp-=3] = yyrv;
        return 5;
    }

    private int yyr5() { // NODE_DECLARATION : NODE_DECLARATION COMMA VAR
        {System.out.println("Node acquired: "+((String)yysv[yysp-1]));
                //insert the control to verify the presence of ((String)yysv[yysp-1]) in the variable list
                if (listOfNames.contains(((String)yysv[yysp-1]))){
                    errorString = "The name (node) "+ ((String)yysv[yysp-1]) +" is already used";
                    return error;
                    }
                listOfNames.add(((String)yysv[yysp-1]));
        }
        yysv[yysp-=3] = yyrv;
        return 63;
    }

    private int yyr6() { // NODE_DECLARATION : VAR
        {System.out.println("Node acquired: "+((String)yysv[yysp-1]));
                //insert the control to verify the presence of ((String)yysv[yysp-1]) in the variable list
                if (listOfNames.contains(((String)yysv[yysp-1]))){
                    errorString = "The name (node) "+ ((String)yysv[yysp-1]) +" is already used";
                    return error;
                    }
                listOfNames.add(((String)yysv[yysp-1]));
                                if(startLocation.isEmpty())
                                startLocation = ((String)yysv[yysp-1]);
        }
        yysv[yysp-=1] = yyrv;
        return 63;
    }

    private int yyr9() { // NUMERIC_REST : VAR EQ LSBRACK RANGEFLT POINT POINT RANGEFLT RSBRACK l_init NUMERIC
        { System.out.println("Variable acquired: "+((String)yysv[yysp-10]));
                Declaration variable = new Declaration (((String)yysv[yysp-10]), ((Float)yysv[yysp-1]), ((Float)yysv[yysp-7]), ((Float)yysv[yysp-4]));
                if (listOfNames.contains(((String)yysv[yysp-10]))){
                    errorString = "the name (variable) "+ ((String)yysv[yysp-10]) +" is already used";
                    return error;
                }
                if (!variable.isRangeCorrect()){
                    errorString = "Error in the range of the variable "+ ((String)yysv[yysp-10]) +" control it!";
                    return error;
                }
                listOfClocks.add(variable);
                listOfNames.add(((String)yysv[yysp-10]));
        }
        yysv[yysp-=10] = yyrv;
        switch (yyst[yysp-1]) {
            case 101: return 110;
            case 90: return 96;
            default: return 120;
        }
    }

    private int yyr10() { // RANGEFLT : NUMERIC
        {yyrv = ((Float)yysv[yysp-1]);}
        yysv[yysp-=1] = yyrv;
        return yypRANGEFLT();
    }

    private int yyr11() { // RANGEFLT : PLUSINF
        {yyrv = new Float(Float.MAX_VALUE);}
        yysv[yysp-=1] = yyrv;
        return yypRANGEFLT();
    }

    private int yyr12() { // RANGEFLT : MINUSINF
        {yyrv = new Float(Float.MIN_VALUE);}
        yysv[yysp-=1] = yyrv;
        return yypRANGEFLT();
    }

    private int yypRANGEFLT() {
        switch (yyst[yysp-1]) {
            case 113: return 122;
            default: return 140;
        }
    }

    private int yyr68() { // RESET : RESET COMMA VAR
        {System.out.println("Reset " + ((String)yysv[yysp-1]));
        ArrayList support = new ArrayList<Integer>();
        support.addAll(((ArrayList)yysv[yysp-3]));
        support.add(new Integer(Utility.getLiteralIndex(((String)yysv[yysp-1]), decs)));
        yyrv = support;}
        yysv[yysp-=3] = yyrv;
        return 114;
    }

    private int yyr69() { // RESET : VAR
        {System.out.println("Reset " + ((String)yysv[yysp-1]));
        ArrayList support = new ArrayList<Integer>();
        support.add(new Integer(Utility.getLiteralIndex(((String)yysv[yysp-1]), decs)));
        yyrv = support;}
        yysv[yysp-=1] = yyrv;
        return 114;
    }

    private int yyr70() { // RESET : /* empty */
        {yyrv = null;}
        yysv[yysp-=0] = yyrv;
        return 114;
    }

    private int yyr20() { // SHORTBOOL : TT
        {yyrv = new Boolean(true);}
        yysv[yysp-=1] = yyrv;
        return 22;
    }

    private int yyr21() { // SHORTBOOL : FF
        {yyrv = new Boolean(false);}
        yysv[yysp-=1] = yyrv;
        return 22;
    }

    private int yyr31() { // SIM : LS
        {yyrv = new Integer(Constant.LS);}
        yysv[yysp-=1] = yyrv;
        return yypSIM();
    }

    private int yyr32() { // SIM : LEQ
        {yyrv = new Integer(Constant.LEQ);}
        yysv[yysp-=1] = yyrv;
        return yypSIM();
    }

    private int yyr33() { // SIM : EQ
        {yyrv = new Integer(Constant.EQ);}
        yysv[yysp-=1] = yyrv;
        return yypSIM();
    }

    private int yyr34() { // SIM : GEQ
        {yyrv = new Integer(Constant.GEQ);}
        yysv[yysp-=1] = yyrv;
        return yypSIM();
    }

    private int yyr35() { // SIM : GR
        {yyrv = new Integer(Constant.GR);}
        yysv[yysp-=1] = yyrv;
        return yypSIM();
    }

    private int yypSIM() {
        switch (yyst[yysp-1]) {
            case 81: return 87;
            default: return 51;
        }
    }

    private int yyr22() { // STATES : NODE ARCS EDGE_SET STATES
        {
        float prob_sum = 0;
        for(int i = 0; i < ((ArrayList)yysv[yysp-2]).size(); i++)
        {
         prob_sum+= ((Edge) ((ArrayList)yysv[yysp-2]).get(i)).getProbability();
        }
        if(prob_sum != 1)
        {
         errorString = "The sum of the probability inserted in the multiarch is different from 1 and is" + prob_sum;
            return error;
        } 
        else
        {
       
        if(((Boolean)yysv[yysp-3]).booleanValue())
                {
                        if(!urEdges.containsKey(((String)yysv[yysp-4])))
                                urEdges.put(((String)yysv[yysp-4]), new ArrayList<ArrayList<Edge>>());
                        urEdges.get(((String)yysv[yysp-4])).add(((ArrayList)yysv[yysp-2]));
                }
                else 
                {
         if(!edges.containsKey(((String)yysv[yysp-4])))
                                edges.put(((String)yysv[yysp-4]), new ArrayList<ArrayList<Edge>>());
                        edges.get(((String)yysv[yysp-4])).add(((ArrayList)yysv[yysp-2]));
        }
        }
        }
        yysv[yysp-=4] = yyrv;
        return yypSTATES();
    }

    private int yyr23() { // STATES : NODE ARCS EDGE_SET
        {
        float prob_sum = 0;
        for(int i = 0; i < ((ArrayList)yysv[yysp-1]).size(); i++)
        {
         prob_sum+= ((Edge) ((ArrayList)yysv[yysp-1]).get(i)).getProbability();
        }
        if(prob_sum != 1)
        {
         errorString = "The sum of the probability inserted in the multiarch is different from 1 and is" + prob_sum;
            return error;
        } 
        else
         {
       
        if(((Boolean)yysv[yysp-2]).booleanValue())
                {
                        if(!urEdges.containsKey(((String)yysv[yysp-3])))
                                urEdges.put(((String)yysv[yysp-3]), new ArrayList<ArrayList<Edge>>());
                        urEdges.get(((String)yysv[yysp-3])).add(((ArrayList)yysv[yysp-1]));
                }
                else 
                {
         if(!edges.containsKey(((String)yysv[yysp-3])))
                                edges.put(((String)yysv[yysp-3]), new ArrayList<ArrayList<Edge>>());
                        edges.get(((String)yysv[yysp-3])).add(((ArrayList)yysv[yysp-1]));
        }
        }
        }
        yysv[yysp-=3] = yyrv;
        return yypSTATES();
    }

    private int yypSTATES() {
        switch (yyst[yysp-1]) {
            case 3: return 6;
            default: return 42;
        }
    }

    private int yyr3() { // VARIABLESORNOT : VARIABLE_DEC DEFINITIONS SEMI
        {
                        // does nothing!
                }
        yysv[yysp-=3] = yyrv;
        return 111;
    }

    private int yyr4() { // VARIABLESORNOT : /* empty */
        {
                        // does nothing!
                }
        yysv[yysp-=0] = yyrv;
        return 111;
    }

    protected String[] yyerrmsgs = {
    };


        /** Reference to the used lexical analyzer instance. */
        private FishPassLexer lexer;

        /** Loaded with a string indicating the error position, if one occurs */
        private String errorString = "";

        // DATA STRUCTURE FOR STORING AUTOMATON INFORMATION
        /** <code>Map</code> with all the automaton edges, for each location */
        private HashMap<String, ArrayList<ArrayList<Edge>>> edges = new HashMap<String, ArrayList<ArrayList<Edge>>>();
        /** <code>Map</code> with all the automaton URGENT edges, for each location */
        private HashMap<String, ArrayList<ArrayList<Edge>>> urEdges = new HashMap<String, ArrayList<ArrayList<Edge>>>();
        // used to check COLLISIONS among locations, clocks and variables
        /** <code>ArrayList</code> with all the declared automaton names */
        private ArrayList<String> listOfNames = new ArrayList<String>();

        /**
         * <code>Map</code> with all the automaton locations and corresponding
         * invariants
         */
        private HashMap<String, ConstraintExpression> locations = new HashMap<String, ConstraintExpression>();
        /** <code>ArrayList</code> with all the declared automaton clocks */
        private ArrayList<Declaration> listOfClocks = new ArrayList<Declaration>();
        /** <code>ArrayList</code> with all the declared automaton variables */
        private ArrayList<Declaration> listOfVariables = new ArrayList<Declaration>();
        /** <code>Array</code> of <code>Declaration</code>s for clocks and variables */
        private Declaration[] decs;
        /** <code>ArrayList</code> with all the declared automaton variables */
        private ArrayList<Qvi> workingQueue = new ArrayList<Qvi>();
        /**
         * Initial EPDTA location: it is ALWAYS the FIRST location declared in the
         * input
         */
        private String startLocation = "";
        /** Max time execution input for the EPDTA */
        private int max;

        // METHOD SECTION. THEY OPERATE ON THE PARSER FIELDS AND ON THE PARSER
        // OUTPUT

        /**
         * Returns a string representing the error the parser encountered.
         * 
         * @return the <code>String</code> representing the error occurred
         */
        public String getError() {
                return errorString;
        }

        /**
         * Error function called from the parser for syntax error in the token
         * input. If an incorrect token (i.e. an unrecognizable token) is found from
         * the lexer or else when "error" token is returned in the semantics meaning
         * the tokens found are not acceptable in the particular context.
         */
        private void yyerror(String msg) {
                String err = "Error at line " + (lexer.linenr() + 1)
                                + " and at column " + (lexer.columnnr() + 1)
                                + " with character(s) \"" + lexer.yytext() + "\".\n";
                err = err + errorString;
                System.out.println(err);
        }

        /**
         * Called from the parser to get the next available token.
         * 
         * @return the <code>integer</code> value associated with the next token or
         *         the <code>error token</code> if an error occurs, or
         *         <code>endofinput token</code> if no more token are available
         */
        private int nextToken() {
                try {
                        return lexer.yylex();
                } catch (Exception e) {
                        return error;
                }
        }

        public ArrayList<Declaration> getVariables() {
                return listOfVariables;
        }

        public ArrayList<Declaration> getClocks() {
                return listOfClocks;
        }

        public MDPGraph<String, MultiArc> createMDP(String input) {
                // 1) Clear support data structures and variables
                startLocation = ""; // TODO metodo di pulitura delle strutture di
                                                        // supporto
                // 2) Parsing the input file [loading support data structures]
                if (parseInput(input)) {
                        // 3) Semantics application EPDTA --> MDP
                        return epdta2mdp();
                }
                return null;
        }

        private boolean parseInput(String inputFile) {
                try {
                        lexer = new FishPassLexer(new FileReader(inputFile));
                        lexer.yylex();
                        if (!parse()) {
                                System.out.print("Parsing error - abort...");
                                System.out.print("Parser error status: "
                                                + (yyerrno > 0 ? yyerrmsgs[yyerrno] : "unknown"));
                                return false;
                        }
                } catch (Exception Ex) {
                        return false;
                }
                return true;
        }

        private MDPGraph<String, MultiArc> epdta2mdp() {
                try {
                        // 1) Initial (Q,V,I) creation
                        Qvi qviS = new Qvi(startLocation, listOfClocks.size(),
                             listOfVariables);
                        MDPGraph<String, MultiArc> g = new MDPGraph<String, MultiArc>();
                        // 2) Addition of the initial (Q, V, I) to the graph (and to the
                        // iteration stack)
                        g.addVertex(qviS.toString());
                        workingQueue.add(qviS);
                        // 3) Start iterating over the (Q, V, I) in the working queue
                        while (!workingQueue.isEmpty()) {
                                Qvi current = workingQueue.remove(0);
                                // FIRST RULE: STOP
                                if (current.getTime() == max) {
                                        String stop = new Qvi("STOP", current.getClocks(),
                                                        current.getVariables()).toString();
                                        // check if the stop node already exists (e.g. two nodes
                                        // with equal variables and clock can end to the same STOP!)
                                        if (!g.contains(stop.toString()))
                                                g.addVertex(stop.toString());
                                        // TODO rivedere gestione grafo
                                        g.addMultiArc(current.toString(),
                                                        new MultiArc(stop.toString()));
                                        continue;
                                }
                                // SECOND RULE: URGENT
                                if (isUrgentEnabled(current)) {
                                        functionalSemanticApplication(g, current, urEdges);
                                } else {
                                        // THIRD RULE: TIME
                                        Qvi increment = new Qvi(current.getLocation(),
                                                        current.getClocks(), current.getVariables());
                                        increment.makeTimePass(); // semantic application!!
                                        if (!g.contains(increment.toString())) {
                                                g.addVertex(increment.toString());
                                                workingQueue.add(increment);
                                        }
                                        // TODO rivedere gestione grafo
                                        g.addMultiArc(current.toString(),
                                                        new MultiArc(increment.toString()));
                                        // FORTH RULE: NOT URGENT // TIME and NOT URGENT rules are
                                        // applied "at the same code level" because we build the
                                        // final graph as a BFS over the graph; since time and
                                        // functional edges coexist they are built together
                                        functionalSemanticApplication(g, current, edges);
                                }
                        }
                        return g;
                } catch (Exception e) {
                        System.err.println("Errore durante la creazione del MDP. "
                                        + e.getMessage());
                        return null;
                }
        }

        private void functionalSemanticApplication(MDPGraph<String, MultiArc> g,
                        Qvi current, HashMap<String, ArrayList<ArrayList<Edge>>> map) {
                ArrayList<ArrayList<Edge>> edgez = map.get(current.getLocation());
                if (edgez == null)
                        return;
                // else...
                for (ArrayList<Edge> eU : edgez)
                        if (isGuardSatified(eU.get(0), current)) {
                                MultiArc m = new MultiArc(eU.size()); // multiarc creation
                                for (Edge e : eU) {
                                        Qvi next = new Qvi(e.getLabel(), current.getClocks(),
                                                        current.getVariables());
                                        // apply resetZ and assignmentZ of the edge
                                        Utility.ApplyResets(next.getClocks(), e.getResets());
                                        Utility.ApplyAssignments(e.getAssignments(), decs,
                                                        next.getClocks(), next.getVariables());
                                        // check vertex...
                                        if (!g.contains(next.toString())) {
                                                g.addVertex(next.toString());
                                                workingQueue.add(next);
                                        }
                                        // ...finally add sub-edge to the multiarc
                                        m.addArc(next.toString(), e.getProbability());
                                }
                                // check multiarc addition to the graph!!!
                                g.addMultiArc(current.toString(), m);
                        }
        }

        private boolean isUrgentEnabled(Qvi current) {
                ArrayList<ArrayList<Edge>> uEdges = urEdges.get(current.getLocation());
                if (uEdges != null) {
                        for (ArrayList<Edge> eU : uEdges)
                                if (isGuardSatified(eU.get(0), current))
                                        return true;
                }
                return false;
        }

        private boolean isGuardSatified(Edge e, Qvi l) {
                if (e.getGuard() == null)
                        return true;
                return e.getGuard()
                                .evaluateGuard(decs, l.getClocks(), l.getVariables());
        }

public void saveMDP(MDPGraph<String, MultiArc> g) {
                BufferedWriter buffered = null;
                try {
                        buffered = new BufferedWriter(new FileWriter("output.txt"));
                        // HEADER START
                        buffered.write("mdp");
                        buffered.newLine();
                        buffered.write("module EPDTA2PRISM\n");
                        buffered.newLine();
                        buffered.write("//--- Locations ---//");
                        buffered.newLine();
                        buffered.write("LOC: [0.." + g.getVertexCount() + "];");
                        buffered.newLine();
                        buffered.newLine();
                        // HEADER CLOCKS DECLARATION
                        buffered.write("//--- Clocks ---//");
                        buffered.newLine();
                        for (Declaration d : listOfClocks) {
                                buffered.write(d.getVar().toLowerCase() + " : [0" + " .. "
                                                + max + "] init 0;");
                                buffered.newLine();
                        }
                        buffered.newLine();
                        // HEADER VARIABLES DECLARATION
                        buffered.write("//--- Variables ---//");
                        buffered.newLine();
                        for (Declaration d : listOfVariables) {
                                if (d.getBool() == null)
                                        buffered.write(d.getVar().toLowerCase() + " : ["
                                                        + d.getMin() + ".." + d.getMax() + "] init 0;");
                                else
                                        buffered.write(d.getVar().toLowerCase()
                                                        + " : bool init false;");
                                buffered.newLine();
                        }
                        buffered.newLine();
                        buffered.write("//--- Transitions ---//");
                        buffered.newLine();
                        // BODY
                        for (int i = 0; i < g.getVertexCount(); i++) {
                                ArrayList<MultiArc> arcs = g.getArcs(i);
                                String sourceLabel = g.Nodes.get(i);
                                for (MultiArc arc : arcs) {
                                        buffered.write(getPTAString(sourceLabel,
                                                        g.getVertexIndex(sourceLabel), arc, g));
                                        // TAIL
                                        buffered.write(";");
                                        buffered.newLine();
                                }
                        }
                        buffered.newLine();
                        buffered.write("endmodule");
                } catch (FileNotFoundException ex) {
                        ex.printStackTrace();
                } catch (IOException ex) {
                        ex.printStackTrace();
                } finally {
                        try {
                                buffered.close();
                                buffered = null;
                        } catch (IOException ex) {
                                ex.printStackTrace();
                        }
                }
        }

        private String getPTAString(String sourceLabel, int sourceIndex,
                        MultiArc arc, MDPGraph<String, MultiArc> g) {
                String locLabel = sourceLabel;
                String sourceQvi = getPTAState(sourceLabel, sourceIndex);
                String probLabels = "";
                //
                for (int j = 0; j < arc.arcs.length; j++) {
                        String target = (String) (arc.arcs[j].second);
                        locLabel += "_TO_" + target;
                        probLabels += "+ "
                                        + arc.arcs[j].first
                                        + ":"
                                        + getPTAState(target, g.getVertexIndex(target), sourceLabel);
                }
                return new String("[" + locLabel + "] " + sourceQvi + " -> "
                                + probLabels.substring(2));
        }

        private String getPTAState(String qvi, int index) {
                String dump = "LOC=" + index;
                String[] clocks = qvi.split("__")[1].split("_");
                String[] vars = qvi.split("__")[2].split("_");
                for (int i = 0; i < clocks.length; i++)
                        dump += " & " + listOfClocks.get(i).getVar() + "=" + clocks[i];
                for (int i = 0; i < vars.length; i++)
                        dump += " & "
                                        + listOfVariables.get(i).getVar()
                                        + "="
                                        + (listOfVariables.get(i).isBool() ? vars[i].equals("0.0") ? "false"
                                                        : "true"
                                                        : vars[i]);
                return dump;
        }

        private String getPTAState(String qviD, int index, String qviS) {
                String[] clocksS = qviS.split("__")[1].split("_");
                String[] varsS = qviS.split("__")[2].split("_");
                String[] clocksD = qviD.split("__")[1].split("_");
                String[] varsD = qviD.split("__")[2].split("_");
                String dump = "(LOC'=" + index + ")";
                for (int i = 0; i < clocksD.length; i++)
                        if (clocksD[i].equalsIgnoreCase("0")
                                        && !clocksS[i].equalsIgnoreCase("0"))
                                dump += " & (" + listOfClocks.get(i).getVar() + "'=0)";
                for (int i = 0; i < varsD.length; i++)
                        if (varsD[i].equals(varsS[i]))
                                dump += " & ("
                                                + listOfVariables.get(i).getVar()
                                                + "'="
                                                + (listOfVariables.get(i).isBool() ? varsD[i]
                                                                .equals("0.0") ? "false" : "true" : varsD[i])
                                                + ")";
                return dump;
        }

}
